package com.itheima.performanceanalysis;

import java.io.*;

public class Test {

    private static final String SRC_FILE_PATH = "E:\\java.avi";
    private static final String DEST_FILE_PATH = "D:\\";

    public static void main(String[] args) {

        //缓冲流和低级流的性能分析

        //1.使用低级的字节流按每次读取一个字节的方式复制文件：非常慢，禁止使用！
        copyFileByByte();
        //2.使用缓冲流的字节流按每次读取一个字节的方式复制文件：虽然是高级的流，但是速度还是慢，不建议使用！
        copyFileByBuffer();
        //3.使用低级的字节流按每次读取一个字节数组的方式复制文件：比较慢，勉强能用。
        copyFileByByteArray();
        //4.使用缓冲流的字节流按每次读取一个字节数组的方式复制文件：快，推荐使用！
        copyFileByBufferArray();
    }

    //1.使用低级的字节流按每次读取一个字节的方式复制文件
    public static void copyFileByByte() {

        //拿到系统当前时间
        long start = System.currentTimeMillis(); //此刻时间毫秒值：从1970-01-01 00:00:00开始到此刻的时间毫秒值
        try (
                //1.创建一个字节输入流对象，与源文件接通
                InputStream fis = new FileInputStream(SRC_FILE_PATH);
                //2.创建一个字节输出流对象，与目标文件接通
                OutputStream fos = new FileOutputStream(DEST_FILE_PATH + "java1.avi");
        ) {
            //3.读取一个字节，写入一个字节
            int b;
            while ((b = fis.read()) != -1) {
                fos.write(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("使用低级的字节流按每次读取一个字节的方式复制文件耗时：" + (end - start) / 1000.0 + "s");

    }

    //2.使用缓冲流的字节流按每次读取一个字节的方式复制文件
    public static void copyFileByBuffer() {

        //拿到系统当前时间
        long start = System.currentTimeMillis(); //此刻时间毫秒值：从1970-01-01 00:00:00开始到此刻的时间毫秒值
        try (
                //1.创建一个字节输入流对象，与源文件接通
                InputStream fis = new FileInputStream(SRC_FILE_PATH);
                //2.创建一个字节输出流对象，与目标文件接通
                OutputStream fos = new FileOutputStream(DEST_FILE_PATH + "java2.avi");
                //3.创建一个缓冲输入流对象，与源文件接通
                BufferedInputStream bis = new BufferedInputStream(fis);
                //4.创建一个缓冲输出流对象，与目标文件接通
                BufferedOutputStream bos = new BufferedOutputStream(fos);
        ) {
            //5.读取一个字节，写入一个字节
            int b;
            while ((b = bis.read()) != -1) {
                bos.write(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("使用缓冲流的字节流按每次读取一个字节的方式复制文件耗时：" + (end - start) / 1000.0 + "s");

    }

    //3.使用低级的字节流按每次读取一个字节数组的方式复制文件
    public static void copyFileByByteArray() {

        //拿到系统当前时间
        long start = System.currentTimeMillis(); //此刻时间毫秒值：从1970-01-01 00:00:00开始到此刻的时间毫秒值
        try (
                //1.创建一个字节输入流对象，与源文件接通
                InputStream fis = new FileInputStream(SRC_FILE_PATH);
                //2.创建一个字节输出流对象，与目标文件接通
                OutputStream fos = new FileOutputStream(DEST_FILE_PATH + "java3.avi");
        ) {
            //3.读取一个字节数组，写入一个字节数组
            byte[] bs = new byte[1024];     //可以将大小改为1024*8，性能会提示
            int len;
           while ((len = fis.read(bs)) != -1) {
               fos.write(bs, 0, len);
           }
        }catch (Exception e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("使用低级的字节流按每次读取一个字节数组的方式复制文件耗时：" + (end - start) / 1000.0 + "s");
    }

    //4.使用缓冲流的字节流按每次读取一个字节数组的方式复制文件
    public static void copyFileByBufferArray() {

        //拿到系统当前时间
        long start = System.currentTimeMillis(); //此刻时间毫秒值：从1970-01-01 00:00:00开始到此刻的时间毫秒值
        try (
                //1.创建一个字节输入流对象，与源文件接通
                InputStream fis = new FileInputStream(SRC_FILE_PATH);
                //2.创建一个字节输出流对象，与目标文件接通
                OutputStream fos = new FileOutputStream(DEST_FILE_PATH + "java4.avi");
                //3.创建一个缓冲输入流对象，与源文件接通
                BufferedInputStream bis = new BufferedInputStream(fis);
                //4.创建一个缓冲输出流对象，与目标文件接通
                BufferedOutputStream bos = new BufferedOutputStream(fos);

        ) {
            //5.读取一个字节数组，写入一个字节数组
            byte[] bs = new byte[1024];
            int len;
            while ((len = bis.read(bs)) != -1) {
                bos.write(bs, 0, len);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("使用缓冲流的字节流按每次读取一个字节数组的方式复制文件耗时：" + (end - start) / 1000.0 + "s");

    }
}
